class Req {

  /**
   * 构造函数用于初始化设置。
   * 
   * @param {Object} obj - 包含基础URL和超时设置的对象。
   * @param {string} obj.baseUrl - API请求的基础URL。
   * @param {number} obj.timeout - 请求的超时时间（毫秒）。
   */
  constructor(obj = { baseUrl: "127.0.0.1", timeout: 6000 }) {
    this.baseUrl = obj.baseUrl;
    this.timeout = obj.timeout;
  }
  /**
   * 发起网络请求。
   * 
   * 该函数封装了uni.request，提供了请求的拦截器功能，用于统一处理请求和响应。
   * 通过传入请求配置对象，可以定制化每个请求的URL、数据和方法等。
   * 使用Promise处理异步操作，使得请求的成功和失败可以被优雅地处理。
   * 
   * @param {Object} obj - 请求配置对象，包含URL、数据、方法等信息，默认值为{ url: '', data: {}, method: 'GET' }。
   * @returns {Promise} - 返回一个Promise对象，用于处理请求的成功和失败。
   */
  request(obj = { url: '', data: {}, method: 'GET' }) {
    // 通过请求拦截器处理请求配置
    let req = this.reqInterceptor(obj)
    return new Promise((resolve, reject) => {
      try {
        // 使用uni.request发起网络请求
        uni.request({
          url: '',
          data: {},
          method: 'GET',
          ...req,
          success: (result) => {
            // 通过响应拦截器处理请求成功的结果
            if (result.statusCode == 400 || result.statusCode == 500 || result.statusCode == 404) {
              reject(result)
            }
            resolve(this.resInterceptor(result))
          },
          fail: (err) => {
            reject(err)
          },
          complete: () => { }
        });
      } catch (err) {
        reject(err)
      }
    })
  }
  get(req) {
    return this.request({ ...req, method: 'GET' })
  }
  post(req) {
    return this.request({ ...req, method: 'POST' })
  }
  uploadFile(req) {
    req = this.reqInterceptor(req)
    return new Promise((resolve, reject) => {
      uni.uploadFile({
        url: req.url, // 你的服务器上传接口URL
        file: req.data.file,
        name: 'file',
        formData: {
          filename: req.data.file.name
        },
        header: {
          Authorization: req.header.Authorization
        },
        success: (res) => {
          res = this.resInterceptor(res)
          res = JSON.parse(res)
          resolve(res)
        },
        fail: (error) => {
          reject(error)
        },
      }).onProgressUpdate((res) => {
        if (req.callback) {
          req.callback(res)
        }
      })
    })
  }
  downloadFile(req) {
    req = this.reqInterceptor(req)
    return new Promise((resolve, reject) => {
      uni.downloadFile({
        url: `${req.url}?filePath=${req.data.filePath}`, // 你的服务器下载接口URL上传接口URL
        success: (res) => {
          if (res.statusCode == 404) {
            reject(res)
          }
          resolve(res)
        },
        fail: (error) => {
          reject(error)
        },
      }).onProgressUpdate((res) => {
        if (req.callback) {
          req.callback(res)
        }
      })
    })
  }
  /**
   * 请求拦截器函数
   * 该函数用于在发送HTTP请求之前修改请求的URL,头部信息等。
   * 
   * @param {Object} req - 原始请求对象
   * @returns {Object} 返回修改后的请求对象
   */
  reqInterceptor(req) {
    // 组合基础URL和请求URL，确保请求的完整URL是正确的
    req.url = this.baseUrl + req.url
    // 设置请求头部的Content-Type，指定请求数据的类型为JSON
    req.header = { 'content-type': 'application/json' }
    // 返回修改后的请求对象，供后续处理使用
    return req
  }
  resInterceptor(res) {
    let { data } = res
    return data
  }
}


export const IP = '47.237.124.57'
export const FG = new Req({
  baseUrl: `http://${IP}:3000/api`, // API请求的基础URL
  timeout: 10000 // 设置请求的超时时间为6秒
})
FG.reqInterceptor = function (req) {
  // 组合基础URL和请求URL，确保请求的完整URL是正确的
  req.url = this.baseUrl + req.url
  // 设置请求头部的Content-Type，指定请求数据的类型为JSON
  req.header = { 'content-type': 'application/json' }
  // 返回修改后的请求对象，供后续处理使用
  let token = uni.getStorageSync('token')
  if (token) {
    req.header.Authorization = `token ${token}`
  }
  return req
}
FG.resInterceptor = function (res) {
  let { data } = res

  if (res.data?.status == 250) {
    uni.showToast({
      icon: 'error',
      title: '登录失效',
      mask: true,
      duration: 800
    }).then(() => {
      uni.removeStorageSync('token')
      uni.removeStorageSync('user')
      uni.reLaunch({
        url: '/pages/login/login'
      }).then(res => {
      }).catch(err => {
      })
    })
  }
  return data
}